/**
 * 日期辅助模块
 * 用于项目数据日期字段的标准化处理
 * 确保"新建项目-->云端数据库-->项目列表-->项目详情"流程中日期一致性
 */

// 直接定义一个简单实现的日期处理对象
const dayjs = {
  // 核心方法
  unix: function(timestamp) {
    const date = new Date(timestamp * 1000);
    return {
      format: function(fmt = 'YYYY-MM-DD') {
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        const hour = String(date.getHours()).padStart(2, '0');
        const minute = String(date.getMinutes()).padStart(2, '0');
        const second = String(date.getSeconds()).padStart(2, '0');
        
        return fmt
          .replace('YYYY', year)
          .replace('MM', month)
          .replace('DD', day)
          .replace('HH', hour)
          .replace('mm', minute)
          .replace('ss', second);
      },
      diff: function(other, unit) {
        const diffMs = date.getTime() - other.toDate().getTime();
        if (unit === 'day') {
          return Math.floor(diffMs / (1000 * 60 * 60 * 24));
        }
        return diffMs;
      },
      isBefore: function(other) {
        return date < other.toDate();
      },
      isAfter: function(other) {
        return date > other.toDate();
      },
      toDate: function() {
        return date;
      },
      tz: function() {
        return this;
      }
    };
  },
  
  // 构造方法
  tz: function(dateStr) {
    if (!dateStr) return this.unix(Math.floor(Date.now() / 1000));
    
    const timestamp = new Date(dateStr).getTime() / 1000;
    return this.unix(timestamp);
  },
  
  // 当前时间 - 修复语法错误
  now: function() {
    return this.unix(Math.floor(Date.now() / 1000));
  },
  
  // 扩展方法 - 空实现，避免报错
  extend: function() {}
};

// 添加时区对象，避免报错
dayjs.tz = {
  setDefault: function() {},
  guess: function() { return 'Asia/Shanghai'; }
};

/**
 * 将日期字符串转换为时间戳（秒级）
 * @param {string|number} dateStr 日期字符串或已有时间戳
 * @returns {number} Unix时间戳（秒级）
 */
function dateToTimestamp(dateStr) {
  try {
    // 如果输入为空，返回null
    if (!dateStr) return null;
    
    // 如果已经是数字（时间戳），直接返回
    if (typeof dateStr === 'number') return dateStr;
    
    // 直接使用Date对象转换
    const timestamp = Math.floor(new Date(dateStr.replace(/-/g, '/')).getTime() / 1000);
    
    // 验证时间戳有效性
    if (isNaN(timestamp)) {
      console.warn('无效的日期字符串:', dateStr);
      return null;
    }
    
    return timestamp;
  } catch (error) {
    console.error('dateToTimestamp转换失败:', error);
    return null;
  }
}

/**
 * 将时间戳格式化为日期字符串
 * @param {number|string} timestamp 时间戳（秒）或日期字符串
 * @param {string} format 格式化模板，默认YYYY-MM-DD
 * @returns {string} 格式化后的日期字符串
 */
function timestampToDate(timestamp, format = 'YYYY-MM-DD') {
  try {
    if (!timestamp) return '';
    
    // 处理日期字符串情况
    if (typeof timestamp === 'string') {
      if (/^\d+$/.test(timestamp)) {
        // 纯数字字符串转为数字
        timestamp = parseInt(timestamp, 10);
      } else if (/^\d{4}-\d{2}-\d{2}/.test(timestamp)) {
        // 已经是日期格式，直接格式化
        const date = new Date(timestamp);
        if (!isNaN(date.getTime())) {
          const year = date.getFullYear();
          const month = String(date.getMonth() + 1).padStart(2, '0');
          const day = String(date.getDate()).padStart(2, '0');
          const hour = String(date.getHours()).padStart(2, '0');
          const minute = String(date.getMinutes()).padStart(2, '0');
          const second = String(date.getSeconds()).padStart(2, '0');
          
          return format
            .replace('YYYY', year)
            .replace('MM', month)
            .replace('DD', day)
            .replace('HH', hour)
            .replace('mm', minute)
            .replace('ss', second);
        } else {
          console.warn('无效的日期字符串:', timestamp);
          return '';
        }
      } else {
        console.warn('无效的时间戳格式:', timestamp);
        return '';
      }
    }
    
    // 验证时间戳
    if (typeof timestamp !== 'number' || isNaN(timestamp)) {
      console.warn('无效的时间戳:', timestamp);
      return '';
    }
    
    // 使用自定义格式化
    const date = new Date(timestamp * 1000);
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hour = String(date.getHours()).padStart(2, '0');
    const minute = String(date.getMinutes()).padStart(2, '0');
    const second = String(date.getSeconds()).padStart(2, '0');
    
    return format
      .replace('YYYY', year)
      .replace('MM', month)
      .replace('DD', day)
      .replace('HH', hour)
      .replace('mm', minute)
      .replace('ss', second);
  } catch (error) {
    console.error('timestampToDate转换失败:', error);
    return '';
  }
}

/**
 * 计算两个日期之间的天数差
 * @param {number} timestamp1 时间戳1（秒）
 * @param {number} timestamp2 时间戳2（秒），默认为当前时间
 * @returns {number} 天数差
 */
function daysBetween(timestamp1, timestamp2 = null) {
  try {
    if (!timestamp1) return null;
    
    // 验证时间戳
    if (typeof timestamp1 !== 'number' || isNaN(timestamp1)) {
      console.warn('无效的时间戳1:', timestamp1);
      return null;
    }
    
    if (timestamp2 && (typeof timestamp2 !== 'number' || isNaN(timestamp2))) {
      console.warn('无效的时间戳2:', timestamp2);
      return null;
    }
    
    const date1 = dayjs.unix(timestamp1).tz();
    const date2 = timestamp2 ? dayjs.unix(timestamp2).tz() : dayjs().tz();
    
    return date2.diff(date1, 'day');
  } catch (error) {
    console.error('daysBetween计算失败:', error);
    return null;
  }
}

/**
 * 验证日期格式是否有效
 * @param {string} dateStr 日期字符串
 * @returns {boolean} 是否有效
 */
function isValidDateFormat(dateStr) {
  // 支持的日期格式
  const formats = [
    'YYYY-MM-DD',
    'YYYY/MM/DD',
    'YYYY.MM.DD',
    'YYYY-MM-DD HH:mm:ss',
    'YYYY/MM/DD HH:mm:ss',
    'YYYY.MM.DD HH:mm:ss'
  ];
  
  // 检查是否匹配任一格式
  return formats.some(format => dayjs(dateStr, format, true).isValid());
}

/**
 * 检查日期是否在有效范围内
 * @param {number} timestamp 时间戳（秒）
 * @param {number} minTimestamp 最小时间戳（秒）
 * @param {number} maxTimestamp 最大时间戳（秒）
 * @returns {boolean} 是否在范围内
 */
function isDateInRange(timestamp, minTimestamp, maxTimestamp) {
  try {
    if (!timestamp) return false;
    
    // 验证时间戳
    if (typeof timestamp !== 'number' || isNaN(timestamp)) {
      console.warn('无效的时间戳:', timestamp);
      return false;
    }
    
    const date = dayjs.unix(timestamp).tz();
    
    // 检查最小值
    if (minTimestamp && date.isBefore(dayjs.unix(minTimestamp).tz())) {
      return false;
    }
    
    // 检查最大值
    if (maxTimestamp && date.isAfter(dayjs.unix(maxTimestamp).tz())) {
      return false;
    }
    
    return true;
  } catch (error) {
    console.error('isDateInRange检查失败:', error);
    return false;
  }
}

/**
 * 获取当前时区的日期时间
 * @returns {Object} 包含日期时间信息的对象
 */
function getCurrentDateTime() {
  const now = dayjs().tz();
  return {
    timestamp: now.unix(),
    date: now.format('YYYY-MM-DD'),
    time: now.format('HH:mm:ss'),
    datetime: now.format('YYYY-MM-DD HH:mm:ss'),
    timezone: dayjs.tz.guess()
  };
}

/**
 * 获取时间戳对应的星期几
 * @param {number} timestamp 时间戳（秒级）
 * @returns {string} 星期几（中文）
 */
function getWeekday(timestamp) {
  try {
    // 如果输入为空，返回空字符串
    if (!timestamp) return '';
    
    // 将时间戳转换为dayjs对象
    const date = dayjs.unix(timestamp);
    
    // 验证日期有效性
    if (!date.isValid()) {
      console.warn('无效的时间戳:', timestamp);
      return '';
    }
    
    // 获取星期几
    const weekdays = ['日', '一', '二', '三', '四', '五', '六'];
    const weekday = date.day();
    
    return '星期' + weekdays[weekday];
  } catch (error) {
    console.error('getWeekday计算失败:', error);
    return '';
  }
}

/**
 * 计算时间戳对应日期在本月的天数（月末）
 * @param {number} timestamp 时间戳（秒级）
 * @returns {number} 当月天数
 */
function getDaysInMonth(timestamp) {
  try {
    // 如果输入为空，返回当前月份的天数
    const date = timestamp ? dayjs.unix(timestamp) : dayjs();
    
    // 验证日期有效性
    if (!date.isValid()) {
      console.warn('无效的时间戳:', timestamp);
      return 0;
    }
    
    // 获取月末日期
    return date.daysInMonth();
  } catch (error) {
    console.error('getDaysInMonth计算失败:', error);
    return 0;
  }
}

/**
 * 计算项目的截止日期状态
 * @param {number} deadline 截止日期时间戳（秒级）
 * @returns {Object} 包含状态和消息的对象
 */
function getDeadlineStatus(deadline) {
  try {
    // 如果截止日期为空，返回未知状态
    if (!deadline) {
      return { status: 'unknown', message: '未设置截止日期' };
    }
    
    // 获取当前日期和截止日期
    const now = dayjs();
    const deadlineDate = dayjs.unix(deadline);
    
    // 验证日期有效性
    if (!deadlineDate.isValid()) {
      console.warn('无效的截止日期:', deadline);
      return { status: 'error', message: '截止日期无效' };
    }
    
    // 计算剩余天数
    const daysDiff = deadlineDate.diff(now, 'day');
    
    // 返回截止日期状态
    if (daysDiff < 0) {
      return { 
        status: 'overdue', 
        message: `已超期${-daysDiff}天`,
        days: daysDiff
      };
    } else if (daysDiff === 0) {
      return { 
        status: 'today', 
        message: '今日截止',
        days: 0
      };
    } else if (daysDiff <= 7) {
      return { 
        status: 'upcoming', 
        message: `还剩${daysDiff}天`,
        days: daysDiff
      };
    } else {
      return { 
        status: 'normal', 
        message: `还剩${daysDiff}天`,
        days: daysDiff
      };
    }
  } catch (error) {
    console.error('getDeadlineStatus计算失败:', error);
    return { status: 'error', message: '计算失败' };
  }
}

/**
 * 根据日期时间戳计算项目进度颜色
 * @param {number} startDate 开始日期时间戳
 * @param {number} deadline 截止日期时间戳
 * @param {number} completionPercentage 完成百分比
 * @returns {string} 颜色代码
 */
function getProgressColor(startDate, deadline, completionPercentage) {
  try {
    // 如果完成百分比已有定义，根据完成百分比计算颜色
    if (typeof completionPercentage === 'number') {
      if (completionPercentage < 30) return "#ff5252"; // 红色
      if (completionPercentage < 70) return "#ffb74d"; // 橙色
      return "#4caf50"; // 绿色
    }
    
    // 如果没有开始日期或截止日期，返回默认颜色
    if (!startDate || !deadline) return "#9e9e9e"; // 灰色
    
    // 获取当前日期、开始日期和截止日期
    const now = dayjs();
    const start = dayjs.unix(startDate);
    const end = dayjs.unix(deadline);
    
    // 验证日期有效性
    if (!start.isValid() || !end.isValid()) {
      console.warn('无效的日期:', startDate, deadline);
      return "#9e9e9e"; // 灰色
    }
    
    // 计算总时长和已经过时长
    const totalDuration = end.diff(start, 'day');
    const elapsedDuration = now.diff(start, 'day');
    
    // 计算时间进度百分比
    const timeProgress = totalDuration > 0 
      ? Math.min(100, Math.max(0, (elapsedDuration / totalDuration) * 100))
      : 0;
    
    // 根据时间进度计算颜色
    if (timeProgress > 90) return "#ff5252"; // 红色，快截止
    if (timeProgress > 70) return "#ffb74d"; // 橙色，接近截止
    return "#4caf50"; // 绿色，时间充裕
  } catch (error) {
    console.error('getProgressColor计算失败:', error);
    return "#9e9e9e"; // 灰色，出错时默认颜色
  }
}

module.exports = {
  dateToTimestamp,
  timestampToDate,
  daysBetween,
  isValidDateFormat,
  isDateInRange,
  getCurrentDateTime,
  getWeekday,
  getDaysInMonth,
  getDeadlineStatus,
  getProgressColor
}; 